package com.htandroid.htandroid.sys;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.app.AlertDialog;
import android.content.Context;
import android.graphics.drawable.Drawable;
import android.util.Log;

import com.htandroid.htandroid.aty.Login_choose;
import com.htandroid.htandroid.entity.Vendor;


public class Basenvo {
    //错误提示框的封装
    static public void messagebox(Context context, Drawable icon, String title, String msg) {
        new AlertDialog.Builder(context)
                .setIcon(icon)
                .setTitle(title)
                .setMessage(msg)
                .create().show();
    }

    //错误提示框的封装
    static public void messagebox(Context context, String title, String msg) {
        new AlertDialog.Builder(context)
                .setTitle(title)
                .setMessage(msg)
                .create().show();
    }

    //数字的格式化函数
    static public String customFormat(String pattern, String value) {
        //先判断是否为数字
        if (value == null) return "";
        if (value.equals("")) return "";
        if (!isNumeric(value)) return "";
        DecimalFormat myFormatter = new DecimalFormat(pattern);
        String output = myFormatter.format(Double.valueOf(value));
        return output;
    }

    static public String customFormat(String pattern, Double value) {
        //先判断是否为数字
        DecimalFormat myFormatter = new DecimalFormat(pattern);
        String output = myFormatter.format(value);
        return output;
    }

    public static boolean isNumeric(String str) {
        //return str.matches("^[-+]?(([0-9]+)([.]([0-9]+))?|([.]([0-9]+))?)$");
        return Pattern.compile("^[-+]?([1-9]+[0-9]*|0)(\\.[\\d]+)?").matcher(str).matches();
    }

    //=============================================
    //日期的格式化函数
    static public String customDateFormat(String pattern, String value) {
        //先判断是否为数字
        if (value.equals("")) return "";
        SimpleDateFormat myFormatter = new SimpleDateFormat(pattern);
        String output = "";
        try {
            output = myFormatter.format(myFormatter.parse(value));
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return output;
    }

    static public String customDateFormat(String pattern, Date value) {
        //先判断是否为数字
        SimpleDateFormat myFormatter = new SimpleDateFormat(pattern);
        String output = myFormatter.format(value);
        return output;
    }

    //==========================================
    //文字末尾增加空格或者截取显示的函数==================
    static public String space_add(String s, Integer lens, Integer ctype) {
        //ctype 为1时,只截取不补空格;为0时,当数据超长时截取,数据短时补空格
        String srtn = "";
        int slen = getWordCount(s);
        //如果字符超过指定长度则只能显示部分
        if (slen > lens) {
            srtn = subString(s, lens);
        } else if (ctype == 0) {
            //末尾增加空格
            srtn = addSpace(s, lens - slen);
        } else {
            srtn = s;
        }
        return srtn;
    }

    public static int getWordCount(String s) {
        int length = 0;
        for (int i = 0; i < s.length(); i++) {
            int ascii = Character.codePointAt(s, i);
            if (ascii >= 0 && ascii <= 255)
                length++;
            else
                length += 2;

        }
        return length;

    }

    public static String addSpace(String str, int countSpace) {
        String resultStr = str;
        ;
        for (int i = 0; i < countSpace; i++) {
            resultStr = resultStr + "  ";
        }
        return resultStr;
    }

    /**
     * 判断传进来的字符串，是否
     * 大于指定的字节，如果大于递归调用
     * 直到小于指定字节数 ，一定要指定字符编码，因为各个系统字符编码都不一样，字节数也不一样
     *
     * @param str 原始字符串
     * @param len 传进来指定字节数
     * @return String 截取后的字符串
     * @throws UnsupportedEncodingException
     */
    public static String subString(String str, int len) {
        if (str == null && "".equals(str)) {
            return null;
        }
        //将字符串中的char数组转换成指定编码方式的byte数组的函数
        byte[] strBytes = null;
        try {
            strBytes = str.getBytes("GBK");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        //得到字符串的长度，判断截取字符串的长度是否在判断的范围内，否则返回原串
        int strLen = strBytes.length;
        if (len >= strLen || len < 1) {
            return str;
        }
        System.out.println("strBytes.length=" + strBytes.length);
        System.out.println("len=" + len);
        int count = 0;
        for (int i = 0; i < len; i++) {
            //将每个字节数组转换为整型数，以为后面根据值的正负来判断是否为汉字
            int value = strBytes[i];
            System.out.print(value + ",");
            //我ABC你-50,-46,65,66,67,-60,-29
            //对于第一种情况：
            //注，一个函数转换成整型数就为两个负整数,上面的”我ABC你“
            //转换成整型数就为-50,-46,65,66,67,-60,-29，但是len=6，所以截取下来的就是-50,-46,65,66,67,-60,count就为3
            //如果是汉字(负)，则统计截取字符串中的汉字所占字节数
            if (value < 0) {
                count++;
            }
            System.out.println("zh count=" + count);
        }
        //依据判断给定的字符串是否含有汉字，利用String类的substring()方法来截取不同的长度
        //根据所统计的字节数，判断截取到字符是否为半个汉字，奇数为半个汉字
        if (count % 2 != 0) {
            //如果在截取长度为1时，则将该汉字取出
            //其他情况则不截取这里的截取长度则按字符长度截取（截取字节长度数-截取汉字字节数/2-截取到的半个汉字的字节数）
            len = (len == 1) ? len : len - count / 2 - 1;
            //len=6-3/2-1=4我ABC
            //System.out.println("处理后的len="+len);
        } else {
            //截取字符长度为字节长度-汉字所占字节长度/2（汉字占两个字节
            len = len - (count / 2);
        }
        return str.substring(0, len);
    }

    //=============================================
    //根据供应商名称或编号查找编号所在位置
    public static String venlistfind(ArrayList<Vendor> venlist, String cvencode) {
        if (venlist != null) {
            for (int j = 0; j < venlist.size(); j++) {
                Vendor cven = venlist.get(j);
                //先找编号
                String val = cven.getCvenCode();
                if (val != null) {
                    //
                    if (val.equals(cvencode)) {
                        //设置tag,tag值写供应商列表的对应行号
                        return String.valueOf(j);
                    }
                }
                //匹配名称
                val = cven.getCvenName();
                if (val != null) {
                    //
                    if (val.equals(cvencode)) {
                        //设置tag,tag值写供应商列表的对应行号
                        return String.valueOf(j);
                    }
                }
            }
        }
        return null;
    }

    //==================================================
    public static Date strToDate(String strDate) {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        ParsePosition pos = new ParsePosition(0);
        Date strtodate = formatter.parse(strDate, pos);
        return strtodate;
    }

    //因为空值问题,所以封装一个判断函数=============================
    public static boolean equal(String s1, String s2) {
        if (s1 == null && s2 == null)//均为空串
            return true;

        if (s1 != null && s1.equals(s2))
            return true;
        return false;
    }

    //比较2个小数大小
    public static String compare(BigDecimal val1, BigDecimal val2) {
        String result = "";
        if (val1.compareTo(val2) < 0) {
            result = "<";
        }
        if (val1.compareTo(val2) == 0) {
            result = "=";
        }
        if (val1.compareTo(val2) > 0) {
            result = ">";
        }
        return result;
    }

    //中文乱码转换
    public static String Iso2Utf8(String iso) {
        String UTF_Str = "";
        String GB_Str = iso;
        boolean is_cN = false;
        try {
            UTF_Str = new String(iso.getBytes("ISO-8859-1"), "UTF-8");
            //Log.i("2","这是转了UTF-8的"+UTF_Str);
            is_cN = Basenvo.isChineseCharacter(UTF_Str);
            //防止有人特意使用乱码来生成二维码来判断的情况
            boolean b = Basenvo.isSpecialCharacter(iso);
            if (b) {
                is_cN = true;
            }
            if (!is_cN) {
                GB_Str = new String(iso.getBytes("ISO-8859-1"), "GB2312");
                //Log.i("3","这是转了GB2312的"+GB_Str);
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return GB_Str;
    }

    //中文乱码转换判断"UTF-8"
    public static final boolean isChineseCharacter(String chineseStr) {
        char[] charArray = chineseStr.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            //是否是Unicode编码,除了"�"这个字符.这个字符要另外处理
            if ((charArray[i] >= '\u0000' && charArray[i] < '\uFFFD') || ((charArray[i] > '\uFFFD' && charArray[i] < '\uFFFF'))) {
                continue;
            } else {
                return false;
            }
        }
        return true;
    }

    //中文乱码判断
    public static final boolean isSpecialCharacter(String str) {
        //是"�"这个特殊字符的乱码情况
        if (str.contains("ï¿½")) {
            return true;
        }
        return false;
    }

    //抛弃asc码超过127的字符,目的是防止中文字符影响条码扫描
    public static String StringLoseChinese(String s) {
        byte[] s_asc = s.getBytes();
        String s_re = "";
        int i = 0;
        for (i = 0; i < s_asc.length; i++) {
            int ascnum = (int) s_asc[i];
            if (ascnum < 128 && ascnum > 0) {
                s_re = s_re + String.valueOf((char) s_asc[i]);
            }
        }
        return s_re;
    }

    //xml中特殊字符替换方法
    public static String AdjDigest(String cDigest) {
        //调整摘要，将特殊字符替换为实体
        //		'<=&lt;  >=&gt;  &=&amp;  '=&apos;  "=&quot;
        String AdjDigest = cDigest;
        if (cDigest.indexOf("&") >= 0) {
            AdjDigest = AdjDigest.replace("&", "&amp;");
        }
        if (cDigest.indexOf("<") >= 0) {
            AdjDigest = AdjDigest.replace("<", "&lt;");
        }
        if (cDigest.indexOf(">") >= 0) {
            AdjDigest = AdjDigest.replace(">", "&gt;");
        }
        if (cDigest.indexOf("'") >= 0) {
            AdjDigest = AdjDigest.replace("'", "&apos;");
        }
        if (cDigest.indexOf("\"") >= 0) {
            AdjDigest = AdjDigest.replace("\"", "&quot;");
        }
        return AdjDigest;
    }
}

